package com.gzu.finalwork.admin.service;

import java.util.Date;
import java.util.List;
import java.util.Random;

import com.gzu.finalwork.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import com.gzu.finalwork.admin.mapper.AdCourierMapper;
import com.gzu.finalwork.entity.courier.Couriers;
import com.gzu.finalwork.entity.user.Users;
import com.gzu.finalwork.user.mapper.UserMapper;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class AdCourierService {
    
    @Autowired
    private AdCourierMapper adCourierMapper;
    
    @Autowired
    private UserMapper userMapper;

    // ==================== 查询方法 ====================
    
    /**
     * 获取所有配送员（带用户信息）
     */
    public List<Couriers> getAllCouriers() {
        return adCourierMapper.selectAllCouriers();
    }

    /**
     * 根据ID查询配送员
     */
    public Couriers getCourierById(Integer id) {
        return adCourierMapper.selectCourierById(id);
    }

    /**
     * 根据用户ID查询配送员
     */
    public Couriers getCourierByUserId(Integer userId) {
        return adCourierMapper.selectCourierByUserId(userId);
    }

    /**
     * 根据工号查询配送员
     */
    public Couriers getCourierByJobNumber(String jobNumber) {
        return adCourierMapper.selectCourierByJobNumber(jobNumber);
    }

    /**
     * 根据区域查询配送员
     */
    public List<Couriers> getCouriersByArea(String area) {
        return adCourierMapper.selectCouriersByArea(area);
    }

    /**
     * 根据状态查询配送员
     */
    public List<Couriers> getCouriersByStatus(String status) {
        return adCourierMapper.selectCouriersByStatus(status);
    }

    /**
     * 条件查询配送员
     */
    public List<Couriers> getCouriersByCondition(Couriers courier) {
        return adCourierMapper.selectCouriersByCondition(courier);
    }

    /**
     * 获取配送员排行榜
     */
    public List<Couriers> getCourierRanking(Integer limit) {
        return adCourierMapper.getCourierRanking(limit != null ? limit : 10);
    }

    // ==================== 新增方法 ====================
    
    /**
     * 添加配送员（同时创建用户）
     */
    @Transactional
    public void addCourierWithUser(Couriers courier) {
        try {
            // 1. 参数验证
            validateCourierForAdd(courier);
            
            // 2. 先创建用户
            String salt = UserService.PasswordUtil.generateSalt();
            String encryptedPassword = UserService.PasswordUtil.encryptPassword("123456", salt);
            Users user = new Users();
            user.setUsername(courier.getName());
            user.setPhone(courier.getPhone());
            user.setEmail(courier.getEmail());
            user.setPassword(encryptedPassword); // 默认密码
            user.setSalt(salt);
            user.setRoles("courier");
            user.setStatus(1);
            
            int userResult = userMapper.insertUser(user);
            if (userResult <= 0) {
                throw new RuntimeException("创建用户失败");
            }
            
            // 3. 再创建配送员记录
            courier.setUserId(user.getUserId().intValue());
            courier.setDeliveryCount(0);
            courier.setEntryDate(new Date());
            
            // 生成工号（如果没有提供）
            if (!StringUtils.hasText(courier.getJobNumber())) {
                courier.setJobNumber(generateJobNumber());
            }
            
            int courierResult = adCourierMapper.insertCourier(courier);
            if (courierResult <= 0) {
                throw new RuntimeException("创建配送员记录失败");
            }
            
            log.info("成功添加配送员：工号={}, 姓名={}, 用户ID={}", 
                courier.getJobNumber(), courier.getName(), courier.getUserId());
                
        } catch (Exception e) {
            log.error("添加配送员失败", e);
            throw new RuntimeException("添加配送员失败：" + e.getMessage());
        }
    }

    // ==================== 更新方法 ====================
    
    /**
     * 更新配送员信息（同时更新用户信息）
     */
    @Transactional
    public void updateCourierWithUser(Integer id, Couriers courier) {
        try {
            // 1. 获取现有配送员信息
            Couriers existingCourier = adCourierMapper.selectCourierById(id);
            if (existingCourier == null) {
                throw new RuntimeException("配送员不存在，ID：" + id);
            }
            
            // 2. 更新配送员表
            courier.setId(id);
            int courierResult = adCourierMapper.updateCourier(courier);
            if (courierResult <= 0) {
                throw new RuntimeException("更新配送员信息失败");
            }
            
            // 3. 如果有用户相关信息需要更新，也更新用户表
            if (StringUtils.hasText(courier.getName()) || 
                StringUtils.hasText(courier.getPhone()) || 
                StringUtils.hasText(courier.getEmail())) {
                
                Users user = new Users();
                user.setUserId(existingCourier.getUserId().longValue());
                if (StringUtils.hasText(courier.getName())) {
                    user.setUsername(courier.getName());
                }
                if (StringUtils.hasText(courier.getPhone())) {
                    user.setPhone(courier.getPhone());
                }
                if (StringUtils.hasText(courier.getEmail())) {
                    user.setEmail(courier.getEmail());
                }
                
                int userResult = userMapper.updateUser(user);
                if (userResult <= 0) {
                    log.warn("更新用户信息失败，配送员ID：{}", id);
                }
            }
            
            log.info("成功更新配送员信息，ID：{}", id);
            
        } catch (Exception e) {
            log.error("更新配送员失败，ID：{}", id, e);
            throw new RuntimeException("更新配送员失败：" + e.getMessage());
        }
    }

    /**
     * 更新配送量
     */
    public void updateDeliveryCount(Integer courierId, Integer increment) {
        int result = adCourierMapper.updateDeliveryCount(courierId, increment);
        if (result <= 0) {
            throw new RuntimeException("更新配送量失败");
        }
    }

    // ==================== 删除方法 ====================
    
    /**
     * 删除配送员（同时删除用户）
     */
    @Transactional
    public void deleteCourier(Integer id) {
        try {
            // 1. 获取配送员信息
            Couriers courier = adCourierMapper.selectCourierById(id);
            if (courier == null) {
                throw new RuntimeException("配送员不存在，ID：" + id);
            }
            
            // 2. 删除配送员记录
            int courierResult = adCourierMapper.deleteCourier(id);
            if (courierResult <= 0) {
                throw new RuntimeException("删除配送员记录失败");
            }
            
            // 3. 删除用户记录
            int userResult = userMapper.deleteUser(courier.getUserId().longValue());
            if (userResult <= 0) {
                log.warn("删除用户记录失败，用户ID：{}", courier.getUserId());
            }
            
            log.info("成功删除配送员，ID：{}，用户ID：{}", id, courier.getUserId());
            
        } catch (Exception e) {
            log.error("删除配送员失败，ID：{}", id, e);
            throw new RuntimeException("删除配送员失败：" + e.getMessage());
        }
    }

    /**
     * 批量删除配送员
     */
    @Transactional
    public void deleteCouriersByIds(List<Integer> ids) {
        for (Integer id : ids) {
            deleteCourier(id);
        }
    }

    // ==================== 统计方法 ====================
    
    /**
     * 统计配送员总数
     */
    public int countCouriers() {
        return adCourierMapper.countCouriers();
    }

    /**
     * 根据状态统计配送员数量
     */
    public int countCouriersByStatus(String status) {
        return adCourierMapper.countCouriersByStatus(status);
    }

    /**
     * 根据区域统计配送员数量
     */
    public int countCouriersByArea(String area) {
        return adCourierMapper.countCouriersByArea(area);
    }

    // ==================== 工具方法 ====================
    
    /**
     * 验证新增配送员参数
     */
    private void validateCourierForAdd(Couriers courier) {
        if (!StringUtils.hasText(courier.getName())) {
            throw new IllegalArgumentException("配送员姓名不能为空");
        }
        if (!StringUtils.hasText(courier.getPhone())) {
            throw new IllegalArgumentException("配送员手机号不能为空");
        }
        if (!StringUtils.hasText(courier.getArea())) {
            throw new IllegalArgumentException("配送区域不能为空");
        }
        
        // 检查手机号是否已存在
        Users existingUser = userMapper.selectByPhone(courier.getPhone());
        if (existingUser != null) {
            throw new IllegalArgumentException("手机号已被使用：" + courier.getPhone());
        }
        
        // 检查工号是否已存在（如果提供了工号）
        if (StringUtils.hasText(courier.getJobNumber())) {
            Couriers existingCourier = adCourierMapper.selectCourierByJobNumber(courier.getJobNumber());
            if (existingCourier != null) {
                throw new IllegalArgumentException("工号已被使用：" + courier.getJobNumber());
            }
        }
    }

    /**
     * 生成随机盐值
     */
    private String generateSalt() {
        return String.valueOf(System.currentTimeMillis());
    }

    /**
     * 生成工号
     */
    private String generateJobNumber() {
        // 格式：C + 年月日 + 4位随机数，例如：C20241201001
        String date = String.format("%tY%tm%td", new Date(), new Date(), new Date());
        Random random = new Random();
        int suffix = random.nextInt(9999) + 1;
        String jobNumber = "C" + date + String.format("%04d", suffix);
        
        // 检查是否已存在，如果存在则重新生成
        Couriers existing = adCourierMapper.selectCourierByJobNumber(jobNumber);
        if (existing != null) {
            return generateJobNumber(); // 递归重新生成
        }
        
        return jobNumber;
    }

    // ==================== 兼容旧方法 ====================
    
    /**
     * 获取所有快递员 - 兼容旧方法
     */
    public List<Couriers> getCouriers() {
        return getAllCouriers();
    }

    /**
     * 添加快递员 - 兼容旧方法
     */
    public void addCourier(Couriers courier) {
        addCourierWithUser(courier);
    }

    /**
     * 修改快递员 - 兼容旧方法
     */
    public void updateCourier(Integer id, Couriers courier) {
        updateCourierWithUser(id, courier);
    }
}
